Internet Surfer 2.0/Internet Surfer 2.0 (Wayzata Technology) (1996).iso/pc/text/mac/faqs.059

Text File | 1996-02-12 | 27.8 KB | 577 lines

Frequently Asked Questions (FAQS);faqs.059



(7) I hear this talk about "+" channels, but I don't see any. What were
they?

    "+" channels were in older server versions. They no longer
exist, and probably will stay dead in later code revisions.

(8) What are good channels to try while using irc?

    #hottub and #initgame are almost always teeming with people.
#hottub is meant to simulate a hot tub, and #initgame is non-stop game
of "inits" (initials). Just join and find out!
    Many irc operators are in #Twilight_Zone ... so if you join
that channel and don't hear much talking, don't worry, it's not because
you joined, operators don't talk much on that channel anyways!

(9) How can I find out more about how + and # channels have changed?

    ftp to cs.bu.edu and look at irc/irc-2.7.CHANGES

(10) What if someone tells me to type something cryptic?

    Never type anything anyone tells you to without knowing what it
is. There is a problem with typing a certain command with the ircII
client that gives anyone immediate control of your client (and thus can
alter your account environment also).

(11) What is NickServ? What if I can't remember my NickServ password?

    To quote from NickServ's help text, NickServ's purpose is to
keep unique nicknames on irc. NickServ sends a warning to anyone else
who signs on with your nickname.  If you don't use IRC for 10 weeks,
your nickname expires for reuse.

    Only a NickServ operator can change your nickserv password.
To find out which NickServ operators are online, send
/msg [e-mail] OPERWHO

Nicknames with a "*" next to them are online at the time.

(12) What is IPCLUB? GIF-Archives of IRC-persons?

        IPCLUB stands for IRC Picture Club. It is an E-Mail service
provided by [e-mail] for all the users of the Internet. For
more help, mail [e-mail] with the subject of "IPCLUB/HELP".

(13) Where can I learn more?

    A good place to start might be downloading the irc tutorials.
They're avaliable via anonymous ftp from cs.bu.edu in
/irc/support/tutorial.* .. You can also join various IRC related mailing
lists. "operlist" is a list that discusses current (and past) server
code, routing, and protocol. You can join by mailing
[e-mail]. You can join the irchat mailing list by
mailing [e-mail]. There is a low traffic ircII mailing
list, mail [e-mail] to be added. Another mailing list,
[e-mail], exists to discuss protocol revisions for the 3.0
release of the ircd, currently in planning. Mail
[e-mail] to be added to that.

(13) What do I do if I'm still confused or have additions to this posting?

    email [e-mail] or ask for help (in #Twilight_Zone) on irc.

--
Helen Trillian Rose                 <[e-mail], [e-mail]>
Electronic Frontier Foundation       email [e-mail] for EFF Info
Kapor Enterprises, Inc.                 Flames to:
Systems and Networks Administration    [e-mail]
Xref: bloom-picayune.mit.edu news.newusers.questions:11845 news.software.readers:3026 news.answers:4746
Path: bloom-picayune.mit.edu!enterpoop.mit.edu!hri.com!spool.mu.edu!darwin.sura.net!haven.umd.edu!umd5!syrinx.umd.edu!phillips
From: [e-mail] (Leanne Phillips)
Newsgroups: news.newusers.questions,news.software.readers,news.answers
Subject: rn KILL file FAQ
Message-ID: <[e-mail]>
Date: 22 Dec 92 02:13:24 GMT
Expires: 21 Jan 93 14:13:17 GMT
Sender: [e-mail]
Reply-To: [e-mail]
Followup-To: news.newusers.questions
Organization: University of Maryland, College Park
Lines: 183
Approved: [e-mail]
Supersedes: <[e-mail]>
Originator: [e-mail]

Archive-name: killfile-faq
Last modified: 23 Oct 1992

Send comments, suggestions, corrections to [e-mail].

  Rn and trn, and other varieties of rn, have a very useful feature called
the KILL file, which allows you to kill (skip over) articles that you don't
want to see.  There is some support for killfiles in xrn, but the support is
limited; nothing in here is guaranteed to work for xrn.  See the xrn
man page.

  KILL files come in two forms:
    Global: In your News directory, you will have the file KILL.
    Local: In your News directory, the killfile for group foo.bar
        will be foo/bar/KILL.
The difference between the two is that there can be one killfile for
each group (the local killfile), and that killfile affects only the
particular newsgroup (foo/bar/KILL affects only foo.bar; baz/quex/KILL
affects only baz.quex, etc).  The global killfile affects all newsgroups.
(There's a way to change the default names of the killfiles, but it's
more complicated than I want to get into here.  See the rn(1) man page.)

  Killfiles allow you to kill articles based on a number of criteria:
a subject line, a general subject, articles from one poster, articles
from one site, articles cross-posted from any other group, or from one
other group in particular, and articles that are follow-ups to anything at
all (that is, anything with the Re: in the subject line).  You can also
kill articles with a particular string anywhere in the article.

  This article assumes you know how to use an editor and that you have
created the directories for any local killfiles you may need.  Remember
that the name of the file is KILL, not kill or Kill; caps are important.

  The general style for building a kill line is:

        /pattern/modifiers:command

Now, that is obviously not useful to know without understanding it.  The
modifiers and commands are all explained in the rn man page, but here are
some useful ones:
    Modifiers:
       a: all, look through the entire article for the pattern
       h: look through the header of the article for the pattern
    Commands:
       m   mark as unread
       j   mark as read
       =   show subject line
If no modifier appears before the colon, only the subject line of the
article is searched.  More than one command can be performed by using
the style:

        /pattern/modifier:command:command
Thus, for instance, you can use j and = together to see the exact subject
lines being killed.
  It doesn't matter if you use uppercase or lowercase in the pattern; the
program will assume they're the same thing.  That is, "Test" and "test"
used in the pattern mean exactly the same thing; only one is necessary.
If you want case to matter, see the rn(1) man page, the 'c' modifier.

  The easiest way to kill a subject line is to kill it from within the
newsgroup.  When the subject line comes up that you want to kill, instead
of using 'n' to skip that article or 'k' to kill the subject for that
session, type 'K'.  The subject line will then be entered into your KILL
file for that group.  If you want to put that line into your global KILL
file, you'll have to do that yourself.  (If you don't need it in your global
file, it's best not to put it there - global kill files slow down your news
reading a lot.  So does using the 'a' modifier; use it sparingly.)
  (I should mention here the easiest way to start editing your kill files.
Typing control-k when you're being asked to pick a newsgroup to read will
start you editing the global killfile; typing the same thing when you're
reading a newsgroup will start up the editing with the kill file for that
group.  If it doesn't exist, it will create it - including the directories
necessary.  This method is particularly recommended for people creating their
first kill file.)

  To kill a general subject, ie any 'test' messages, put in the pattern:
            /test/:j
This will kill anything with the word 'test' in the subject line.

  To kill anything that is a followup to any article, use this pattern:
            /.*Re:/:j
This kills anything beginning with Re:.

  To kill cross-posts from one particular group, say foo.bar, try this:

        /Newsgroups:.*[ ,]foo\.bar/h:j

This searches the header (the 'h' modifier) for any line containing the
string 'Newsgroups:' (which all articles do), as well as the string
'foo.bar'.  The other elements of this line are part of the regular
expression meta-language; see the ed(1) man page for more details.
(Note that all of them are necessary, particularly the '\' before the
'.' in foo\.bar.)

  To kill all cross-posts, from any group at all:

        /Newsgroups:.*,/h:j

If the Newsgroups: line has a ',' in it, it's a cross-post, and therefore
this will find it.
  Note that the above line searches the entire header, included the
Subject: line, for that pattern.  So a Subject line like:
        Subject: I hate the Newsgroups: line, don't you?
would get killed by that pattern, because it has a 'Newsgroups:' part, and
a ','.  To make it work properly, use the 'start of line' character, ^.
The ^ isn't actually there when you look at the header yourself; it just
means to look for the beginning of the line.  So, to kill cross-posts:

        /^Newsgroups:.*,/h:j

should be used instead.  (Use of the ^ is recommended if you know the
pattern you want to catch will be at the beginning of the line; it makes
searching a lot faster.)

  To kill articles from a single poster, you need to know the userid and
nodename of the poster; for this example we'll use [e-mail].

        /From: *noone@anywhere\.all/h:j

  For articles from a particular site, just remove the 'noone' from the
previous line, and articles from the machine 'anywhere.all' will be killed.
(Note again that the \ is important.)

  Now, after all that, you might suddenly find out that you killed articles
from someone whose posts you want to read even if they write about subjects
you don't want to read.  For that, you need to 'unkill' the articles by
them:
       /From: *name of person you want to read/h:m
So, if you suddenly decided you wanted to read [e-mail]'s
postings, after having deleted them above, you would add this line:

        /From: *noone@anywhere\.all/h:m

The 'm' becomes useful suddenly.  You can substitute m for j any time
you need to, up above.  In fact, you can kill everything in a newsgroup and
only read what you want to read by using the 'm' feature, and putting this
line at the top of your KILL file:

                /^/:j
  This method has a problem, though.  Specifically, it marks even those
you've already read (really read, not just marked as read) as unread.  So,
there's another way to do it:
            /pattern/:=:M
(check the rn(1) man page for the M command).  This lists all the subjects
of the new articles, and then gives those articles to the M command.  (You
then have to type 'Y' after the M command has finished.)  (For more complete
information, please write me, and I'll forward on to you an example that was
posted by David Tamkin.)

  Finally, you can kill (or mark, of course) a particular pattern appearing
anywhere in the article, as opposed to just the Subject: line or the header:

            /pattern/a:j
               and
            /pattern/a:m

This is useful for, for instance, killing all articles by a certain user,
followups to said user's articles, and even mention of the user by userid
and node, or, conversely, by marking all of those conversations as unread
so you can read them if they've been killed accidentally by your other
entries.

  Further information is available in the rn man page, particularly on
other available commands and modifiers.  Regular expression syntax is
in the ed(1) man page; the xrn man page gives information about the quirks
of xrn in relation to killfiles.

  I'd like to thank Jonathan Kamens and Rich Salz in particular for their
help, and everyone else who's sent in comments, criticisms, and suggestions;
keep them coming, folks!

Minor administrative note to the suggestors: Several people have suggested
that, in junking all of the articles and then marking only the desirable
ones to read, you need to use the 'r' modifier (search read articles as
well as unread).  According to the man page I read, you don't need that;
if 'm' is the first command, the 'r' is assumed.  If anyone wants to test
this and tell me it's wrong, please do.  But please only tell me if it's
wrong; I'll assume it's right until someone tells me otherwise. :-)

Leanne Phillips
"Go not unto the Elves for counsel, for they will say both yea and nay."
"Now is _not_ a good time, Keiko!" - Worf, "Disaster"
"Variety is the spice of life, and I don't want to die." - Scott Borst
Xref: bloom-picayune.mit.edu news.answers:4542 sci.math.num-analysis:6341
Path: bloom-picayune.mit.edu!enterpoop.mit.edu!news.media.mit.edu!micro-heart-of-gold.mit.edu!rutgers!sun-barr!cs.utexas.edu!uunet!timbuk.cray.com!walter.cray.com!jwg
From: [e-mail] (John W. Gregory)
Newsgroups: news.answers,sci.math.num-analysis
Subject: Linear Programming FAQ
Summary: A List of Frequently Asked Questions about Linear Programming
Keywords: FAQ, LP, Linear Programming
Message-ID: <[e-mail]>
Date: 11 Dec 92 19:44:49 GMT
Expires: 02/14/93
Reply-To: [e-mail] (John W. Gregory)
Followup-To: sci.math.num-analysis
Organization: Cray Research, Inc., Eagan MN USA
Lines: 707
Approved: [e-mail]
Originator: jwg@ceres
Nntp-Posting-Host: ceres.cray.com

Posted-By: auto-faq 2.4
Archive-name: linear-programming-faq
Last-modified: 1992/12/11


           Linear Programming - Frequently Asked Questions List
                                 (lp_faq)
                   Most recent update: December 11, 1992

--------------------------------------------------------------------------

0.  "What's in this FAQ?"

A:  Table of Contents
    0.  "What's in this FAQ?"  (Oh no! Is this a recursion?)
    1.  "What is Linear Programming?"
    2.  "Where is there a good code, preferably public domain, to solve
         Linear Programming problems?"
    3.  "Oh, and we also want to solve it as an integer program. I think
         there will be only a few thousand variables or so."
    4.  "I've written my own optimization code.  Where are some test models?"
    5.  "What is MPS format?"
    6.  "What software is there for non-linear optimization?"
    7.  "What references are there in this field?"
    8.  "Just a quick question..."
    9.  "Who maintains this FAQ list?"

--------------------------------------------------------------------------

1.  "What is Linear Programming?"

A:  A linear program (LP) is a problem that can be put into the form

    minimize   cx
    subject to Ax=b
                x>=0

where x is a vector to be solved for, A is a matrix of known coefficients,
and c and b are vectors  of known coefficients.  All these entities must
have consistent dimensions, of course, and you can add "transpose" symbols
to taste.  The matrix A is generally not square, hence you don't solve an
LP by just inverting A.  Usually A has more columns than rows, so  Ax=b
is therefore underdetermined, leaving great latitude in the choice of x
with which to minimize cx.

Other formulations can be used in this framework.  For instance, if you
want to maximize instead of minimize, multiply the c vector by -1.  If
you have constraints that are inequalities rather than equations, you
can introduce one new variable (a "slack") for each inequality and treat
the augmented row of the matrix as an equation.  LP codes will often
take care of such "bookkeeping" for you.

LP problems are usually solved by a technique known as the Simplex Method,
developed in the 1940's and after.  Briefly stated, this method works by
taking a sequence of square submatrices of A and solving for x, in such a
way that successive solutions always improve, until a point is reached
where improvement is no longer possible.  A family of LP algorithms known
as Interior Point methods has been developed starting in the 1980's, that
can be faster for many (but so far not all) problems.  Such methods are
characterized by constructing a sequence of trial solutions that go
through the interior of the solution space, in contrast to the Simplex
Method which stays on the boundary and examines only the corners (vertices).

LP has a variety of uses, in such areas as petroleum, finance, transportation,
forestry, and military.

The word "Programming" is used here in the sense of "planning"; the
necessary relationship to computer programming was incidental to the
choice of name.  Hence the phrase "LP program" to refer to a piece of
software is not a redundancy, although I tend to use the term "code"
instead to avoid the possible ambiguity.

--------------------------------------------------------------------------

2.  "Where is there a good code, preferably public domain, to solve
Linear Programming problems?"

A:  It depends on the difficulty of your models.  LP technology and
computer technology have both made such great leaps that models that
were previously considered "large" are now routinely solved.  Nowadays,
with good commercial software, models with a few thousand constraints
and several thousand variables can be tackled with a PC.  Workstations
can often handle models with variables in the tens of thousands, or even
greater.  It's hard to be specific about sizes and speed, a priori, due
to the wide variation in things like model structure and variation in
factorizing the basis matrices.

There is a recently released public domain code, written in C, called
"lp_solve" that is available on Usenet in the "comp.sources.reviewed"
newsgroup.  Its author (Michel Berkelaar, email at [e-mail])
claims to have solved models with up to 30,000 variables and 50,000
constraints.  My own experience with this code is not quite so uniformly
optimistic (new users of LP are sometimes shocked to learn that just
because a given code has solved a model of a given dimension, it may not
be able to solve all models of the same size).  Still, for someone who
isn't sure just what kind of LP code is needed, it represents a very
reasonable first try, and the price is certainly right.  The code is
archived at anonymous ftp site "ftp.uu.net", in directory
    "/usenet/comp.sources.reviewed/volume02/lp_solve".
It consists of three files, part00.Z, part01.Z and part02.Z.  You should
download them in binary mode, and use the `uncompress` utility to expand
them to normal ASCII format.  The file called part00 contains reviewers'
comments, and the other two files can be unpacked by removing the first
9 lines and executing the files as shell scripts (e.g., `sh part01`).
Then follow the instructions in the README and INSTALL files.

For DOS/PC users, Prof. Timo Salmi at the University of Vaasa in Finland
offers a code called "tslin".  You should be able to access it by ftp at
garbo.uwasa.fi in directory /pc/ts (the current file name is tslin33b.zip,
apparently using ZIP compression), or else I suggest contacting Prof.
Salmi at [e-mail].

The consensus is that the LP code published in Numerical Recipes is not at
all strong, and should be avoided for heavy-duty use.  If your requirement
is for a solver that can handle 100-variable models, it might be okay.

There is an ACM TOMS routine for LP, #552, available from the netlib server,
in directory /netlib/toms.  See the section on test models for detail on
how to use this server.

If you have access to one of the commercial math libraries, such as IMSL or
NAG, you may be able to use an LP routine from there.

If your models prove to be too difficult for free software to handle,
then you can consider acquiring a commercial LP code.  There are dozens
of such codes on the market. I have my own opinions, but for reasons of
space, generality and fairness, I will not attempt even to list the codes
I know of here.  Instead I refer you to the annual survey of LP software
published in "OR/MS Today", a joint publication of ORSA (Operations
Research Society of America) and TIMS (The Institute of Management
Science).  I think it's likely that you can find a copy of the June, 1992
issue, either through a library, or by contacting a member of these two
organizations (most universities probably have several members among the
faculty and student body).  The survey lists almost fifty actively marketed
products.  This publication also carries advertisements for many of these
products, which may give you additional information to help make a decision.

There are many considerations in selecting an LP code.  Speed is important,
but LP is complex enough that different codes go faster on different models;
you won't find a "Consumer Reports" article  8v)  to say with certainty which
code is THE fastest.  I usually suggest getting benchmark results for your
particular type of model if speed is paramount to you.  Benchmarking may
also help determine whether a given code has sufficient numerical stability
for your kind of models.

Other questions you should answer: Can you use a stand-alone code, or do
you need a code that can be used as a callable library, or do you require
source code?  Do you want the flexibility of a code that runs on many
platforms and/or operating systems, or do you want code that's tuned to
your particular hardware architecture (in which case your hardware vendor
may have suggestions)?  Is the choice of algorithm (Simplex, Interior
Point) important to you?  Do you need an interface to a spreadsheet
code?  Is the purchase price an overriding concern?  Is the software
offered at an academic discount (assuming you are at a university)?  How
much hotline support do you think you'll need?

It may not always be true that "you get what you pay for," but it is rare
that you get more than you pay for.  8v)   There is usually a large
difference in LP codes, in performance (speed, numerical stability,
adaptability to computer architectures) and features, as you climb the
price scale.  If a code seems overpriced to you, you may not yet
understand all of its features.

--------------------------------------------------------------------------

3.  "Oh, and we also want to solve it as an integer program. I think
there will be only a few thousand variables or so."

A:  Hmmmm.  You want
    - Nontrivial model size
    - Integer solutions
    - Public domain code
Pick one or maybe two of the above.  You can't have all three.  8v)

Integer LP models are ones where the answers must not take fractional
values.  It may not be obvious that this is a VERY much harder problem
than ordinary LP, but it is nonetheless true.  The buzzword is "NP-
Completeness", the definition of which is beyond the scope of this
document but means in essence that in the worst case the amount of
time to solve a family of related problems goes up exponentially
as the size of the problem grows.

Integer models may be ones where only some of the variables are to be
integer and others may be real-valued (termed "Mixed Integer LP" or
MILP, or "Mixed Integer Programming" or MIP), or they may be ones where
all the variables must be integral (termed "Integer LP" or ILP).  The
class of ILP is often further subdivided into problems where the only
legal values are {0,1} ("Binary" or "Zero-One" ILP), and general integer
problems.  For the sake of generality, the Integer LP problem will be
referred to here as MIP, since the other classes can be viewed as special
cases of MIP.

You should be prepared to solve far smaller MIP models than the
corresponding LP model, given a certain amount of time you wish to
allow (unless you and your model happen to be very lucky). There exist
models that are considered challenging, with mere hundreds of variables.
Conversely, some models with tens of thousands of variables solve
readily.  It all depends, and the best explanations of "why" always
seem to happen after the fact.  8v)

One exception to this gloomy outlook is that there are certain models
whose LP solution always turns out to be integer.  Best known of these
are the so-called Transportation Problem, Assignment Problem, and
Network-Flow Problem.  It turns out that these problems are best solved
by specialized routines that take major shortcuts in the Simplex Method,
and as a result are relatively quick running.  See the section on
references for a book by Kennington and Helgason, which contains some
source code for Netflo.  Netflo is available by anonymous ftp at
dimacs.rutgers.edu, in directory /pub/netflow/mincost/solver-1, but
I don't know the copyright situation (I used to think you had to buy
the book to get the code).

People are sometimes surprised to learn that MIP problems are solved
using floating point arithmetic.  Although various algorithms for MIP
have been studied, most if not all available general purpose large-scale
LP codes use a method called "Branch and Bound" to try to find an optimal
solution.  In a nutshell, B&B solves MIP by solving a sequence of related
LP models.  Good codes for MIP distinguish themselves more by solving
shorter sequences of LP's, than by solving the individual LP's faster.
Even moreso than with regular LP, a costly commercial code may prove its
value to you if your MIP model is difficult.

As a point of interest, the Simplex Method currently retains an advantage
over the newer Interior Point methods for solving these sequences of LP's.

The public domain code "lp_solve", mentioned earlier, accepts MIP models,
as do a large proportion of the commercial LP codes in the OR/MS Today
survey.  I have seen mention made of algorithm 333 in the Collected
Algorithms from CACM, though I'd be surprised if it was robust enough
to solve large models.

The better MIP codes have numerous parameters and options to give the user
control over the solution strategy. Most have the capability of stopping
before an optimum is proved, printing the best answer obtained so far.
For many MIP models, stopping early is a practical necessity. Fortunately,
a solution that has been proved by the algorithm to be within, say, 1% of
optimality often turns out to be the true optimum, and the bulk of the
computation time is spent proving the optimality. For many modeling
situations, a near-optimal solution is acceptable anyway.

Once one accepts that large MIP models are not typically solved to a
proved optimal solution, that opens up a broad area of approximate
methods, probabilistic methods and heuristics, as well as modifications
to B&B.  Claims have been made for Genetic Algorithms and Simulated
Annealing, though (IMHO) these successes have been problem dependent
and difficult to generalize.  (A reference for GA is David Goldberg,
"Genetic Algorithms in Machine Learning.")

Whatever the solution method you choose, when trying to solve a difficult
MIP model, it is usually crucial to understand the workings of the physical
system (or whatever) you are modeling, and try to find some insight that
will assist your chosen algorithm to work better.  A related observation
is that the way you formulate your model can be as important as the actual
choice of solver.  You should consider getting some assistance if this
is your first time trying to solve a large (>100 variable) problem.

--------------------------------------------------------------------------

4.  "I've written my own optimization code.  Where are some test models?"

A:  In light of the comments above, I hope your aims are fairly modest,
for there are already a lot of good codes out there.  I hope your LP
code makes use of sparse matrix techniques, rather than using a tableau
form of the Simplex method, because the latter usually ends up being
numerically unstable and very slow.

If you want to try out your code on some real-world LP models, there is
a very nice collection of small-to-medium-size ones on netlib.  If you
have ftp access, you can try "ftp research.att.com", using "netlib"
as the Name, and your email address as the password. Do a "cd lp/data"
and look around. There should be a "readme" file, which you would
want to look at first.  Alternatively, you can reach an e-mail
server via "[e-mail]", to which you can send a message saying
"send index from lp/data"; follow the instructions you receive.

The Netlib LP files (after you uncompress them) are in a format called
MPS, which is described in another section of this document.

There is a collection of MIP models, housed at Rice University.  Send
an email message containing "send catalog" to [e-mail], to get
started.

There is a collection of network-flow codes and models at DIMACS (Rutgers
University).  Use anonymous FTP at dimacs.rutgers.edu.  Start looking in
/pub/netflow.  Another network generator is called NETGEN and is available
on netlib (lp/generators).